import random  # used for generating large scale random data

# imports
import pytest  # used for our unit tests
from workload import AlexNet

# unit tests

# 1. BASIC TEST CASES

def test_classify_all_zeros():
    """Test with a list of all zeros."""
    net = AlexNet(num_classes=10)
    features = [0, 0, 0, 0]
    # sum = 0, 0 % 10 = 0, result should be [0, 0, 0, 0]
    codeflash_output = net._classify(features) # 1.76μs -> 1.22μs (44.3% faster)

def test_classify_all_ones():
    """Test with a list of all ones."""
    net = AlexNet(num_classes=5)
    features = [1, 1, 1, 1]
    # sum = 4, 4 % 5 = 4, result should be [4, 4, 4, 4]
    codeflash_output = net._classify(features) # 1.64μs -> 1.18μs (39.0% faster)

def test_classify_mixed_positive():
    """Test with mixed positive integers."""
    net = AlexNet(num_classes=7)
    features = [2, 3, 5]
    # sum = 10, 10 % 7 = 3, result should be [3, 3, 3]
    codeflash_output = net._classify(features) # 1.46μs -> 1.10μs (32.8% faster)

def test_classify_single_element():
    """Test with a single-element list."""
    net = AlexNet(num_classes=3)
    features = [7]
    # sum = 7, 7 % 3 = 1, result should be [1]
    codeflash_output = net._classify(features) # 1.34μs -> 1.09μs (22.9% faster)

def test_classify_negative_numbers():
    """Test with negative numbers in the features."""
    net = AlexNet(num_classes=10)
    features = [-1, -2, -3]
    # sum = -6, -6 % 10 = 4 (Python's mod behavior), result should be [4, 4, 4]
    codeflash_output = net._classify(features) # 1.64μs -> 1.13μs (45.2% faster)

def test_classify_mixed_signs():
    """Test with both positive and negative numbers."""
    net = AlexNet(num_classes=8)
    features = [5, -3, 2, -4]
    # sum = 0, 0 % 8 = 0
    codeflash_output = net._classify(features) # 1.64μs -> 1.22μs (34.5% faster)

def test_classify_empty_list():
    """Test with an empty feature list."""
    net = AlexNet(num_classes=10)
    features = []
    # Should return an empty list
    codeflash_output = net._classify(features) # 1.06μs -> 1.10μs (3.63% slower)

def test_classify_large_num_classes():
    """Test with num_classes larger than sum(features)."""
    net = AlexNet(num_classes=100)
    features = [1, 2, 3]
    # sum = 6, 6 % 100 = 6
    codeflash_output = net._classify(features) # 1.53μs -> 1.15μs (33.2% faster)

# 2. EDGE TEST CASES

def test_classify_sum_exact_multiple_of_num_classes():
    """Test where sum(features) is an exact multiple of num_classes."""
    net = AlexNet(num_classes=6)
    features = [2, 2, 2]  # sum = 6, 6 % 6 = 0
    codeflash_output = net._classify(features) # 1.43μs -> 1.08μs (32.4% faster)

def test_classify_sum_negative_multiple_of_num_classes():
    """Test where sum(features) is a negative multiple of num_classes."""
    net = AlexNet(num_classes=4)
    features = [-2, -2]  # sum = -4, -4 % 4 = 0
    codeflash_output = net._classify(features) # 1.52μs -> 1.23μs (23.5% faster)

def test_classify_num_classes_one():
    """Test with num_classes set to 1, should always return 0."""
    net = AlexNet(num_classes=1)
    features = [10, 20, 30]
    # sum = 60, 60 % 1 = 0
    codeflash_output = net._classify(features) # 1.51μs -> 1.10μs (37.3% faster)

def test_classify_large_negative_sum():
    """Test with a large negative sum."""
    net = AlexNet(num_classes=100)
    features = [-1000, -2000, -3000]
    # sum = -6000, -6000 % 100 = 0
    codeflash_output = net._classify(features) # 1.62μs -> 1.25μs (29.6% faster)

def test_classify_zero_num_classes():
    """Test with num_classes set to zero, should raise ZeroDivisionError."""
    net = AlexNet(num_classes=0)
    features = [1, 2, 3]
    # Modulo by zero should raise ZeroDivisionError
    with pytest.raises(ZeroDivisionError):
        net._classify(features)

def test_classify_non_integer_features():
    """Test with float values in features."""
    net = AlexNet(num_classes=7)
    features = [1.5, 2.5, 3.0]
    # sum = 7.0, 7.0 % 7 = 0.0
    codeflash_output = net._classify(features) # 2.26μs -> 1.87μs (20.9% faster)

def test_classify_large_positive_and_negative():
    """Test with both large positive and negative numbers."""
    net = AlexNet(num_classes=1000)
    features = [999999, -999999, 1000, -1000]
    # sum = 0, 0 % 1000 = 0
    codeflash_output = net._classify(features) # 1.68μs -> 1.33μs (26.4% faster)

def test_classify_features_size_not_used():
    """Test that features_size attribute does not affect classification."""
    net = AlexNet(num_classes=10)
    net.features_size = 1  # change to arbitrary value
    features = [2, 2, 2]
    codeflash_output = net._classify(features) # 1.48μs -> 1.13μs (30.8% faster)

# 3. LARGE SCALE TEST CASES

def test_classify_large_input_list():
    """Test with a large list of features (size 1000)."""
    net = AlexNet(num_classes=123)
    features = [i for i in range(1000)]  # sum = 0+1+...+999 = 499500
    expected_value = 499500 % 123
    codeflash_output = net._classify(features); result = codeflash_output # 46.6μs -> 6.25μs (645% faster)

def test_classify_large_random_input():
    """Test with a large random list of features."""
    net = AlexNet(num_classes=999)
    random.seed(42)
    features = [random.randint(-10000, 10000) for _ in range(999)]
    total = sum(features)
    expected_value = total % 999
    codeflash_output = net._classify(features); result = codeflash_output # 45.4μs -> 9.12μs (398% faster)

def test_classify_large_input_with_floats():
    """Test with a large list of float features."""
    net = AlexNet(num_classes=555)
    random.seed(123)
    features = [random.uniform(-1000, 1000) for _ in range(555)]
    total = sum(features)
    expected_value = total % 555
    codeflash_output = net._classify(features); result = codeflash_output # 29.7μs -> 3.71μs (701% faster)

def test_classify_performance_large_input():
    """Test that function completes quickly for large input (performance test)."""
    net = AlexNet(num_classes=500)
    features = [1] * 1000  # sum = 1000, 1000 % 500 = 0
    codeflash_output = net._classify(features); result = codeflash_output # 41.0μs -> 5.75μs (614% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import random  # used for generating large scale random data

# imports
import pytest  # used for our unit tests
from workload import AlexNet

# unit tests

# 1. Basic Test Cases

def test_classify_empty_features():
    # Test with empty input; should return an empty list
    model = AlexNet(num_classes=10)
    codeflash_output = model._classify([]) # 1.15μs -> 1.19μs (3.36% slower)

def test_classify_single_element():
    # Test with a single feature; output should be [feature % num_classes]
    model = AlexNet(num_classes=10)
    codeflash_output = model._classify([7]) # 1.35μs -> 1.11μs (21.6% faster)
    codeflash_output = model._classify([15]) # 791ns -> 411ns (92.5% faster)

def test_classify_multiple_elements():
    # Test with multiple features; all outputs should be (sum(features) % num_classes)
    model = AlexNet(num_classes=10)
    features = [1, 2, 3]
    expected = [sum(features) % 10] * len(features)
    codeflash_output = model._classify(features) # 1.20μs -> 711ns (69.2% faster)

def test_classify_negative_elements():
    # Test with negative numbers in features
    model = AlexNet(num_classes=10)
    features = [-1, -2, -3]
    expected = [sum(features) % 10] * len(features)
    codeflash_output = model._classify(features) # 1.34μs -> 751ns (78.8% faster)

def test_classify_mixed_elements():
    # Test with a mix of positive and negative numbers
    model = AlexNet(num_classes=10)
    features = [5, -2, 7, -3]
    expected = [sum(features) % 10] * len(features)
    codeflash_output = model._classify(features) # 1.21μs -> 751ns (61.4% faster)

def test_classify_zero_elements():
    # Test with all zeros
    model = AlexNet(num_classes=10)
    features = [0, 0, 0]
    expected = [0] * 3
    codeflash_output = model._classify(features) # 1.44μs -> 951ns (51.7% faster)

def test_classify_different_num_classes():
    # Test with various num_classes values
    features = [2, 4, 6]
    for num_classes in [1, 2, 5, 100, 999]:
        model = AlexNet(num_classes=num_classes)
        expected = [sum(features) % num_classes] * len(features)
        codeflash_output = model._classify(features)

# 2. Edge Test Cases

def test_classify_large_numbers():
    # Test with very large numbers to check for overflow/precision
    model = AlexNet(num_classes=10**6)
    features = [10**12, 10**12, 10**12]
    expected = [sum(features) % 10**6] * len(features)
    codeflash_output = model._classify(features) # 1.39μs -> 811ns (71.8% faster)

def test_classify_minimum_integer():
    # Test with minimum integer values
    model = AlexNet(num_classes=100)
    features = [-(2**63), -(2**63)]
    expected = [sum(features) % 100] * len(features)
    codeflash_output = model._classify(features) # 1.48μs -> 892ns (66.1% faster)

def test_classify_maximum_integer():
    # Test with maximum integer values
    model = AlexNet(num_classes=100)
    features = [2**63-1, 2**63-1]
    expected = [sum(features) % 100] * len(features)
    codeflash_output = model._classify(features) # 1.37μs -> 862ns (59.2% faster)

def test_classify_num_classes_one():
    # If num_classes is 1, all outputs should be 0 regardless of features
    model = AlexNet(num_classes=1)
    features = [random.randint(-1000, 1000) for _ in range(10)]
    codeflash_output = model._classify(features) # 2.09μs -> 1.29μs (61.9% faster)

def test_classify_sum_zero_modulo():
    # Test where sum(features) is exactly divisible by num_classes
    model = AlexNet(num_classes=10)
    features = [2, 3, 5]  # sum = 10, 10 % 10 == 0
    codeflash_output = model._classify(features) # 1.49μs -> 1.14μs (30.6% faster)

def test_classify_all_same_value():
    # All features are the same value
    model = AlexNet(num_classes=7)
    features = [4] * 5
    expected = [sum(features) % 7] * 5
    codeflash_output = model._classify(features) # 1.34μs -> 762ns (76.2% faster)

def test_classify_with_floats():
    # Test with float values (should work if sum() works)
    model = AlexNet(num_classes=10)
    features = [1.5, 2.5, 3.0]
    expected = [int(sum(features)) % 10] * len(features)
    # Since sum(features) is a float, but modulo works, cast to int for expected
    codeflash_output = model._classify(features) # 1.74μs -> 1.14μs (52.6% faster)


def test_classify_non_iterable_features():
    # Test with non-iterable features (should raise error)
    model = AlexNet(num_classes=10)
    with pytest.raises(TypeError):
        model._classify(None)
    with pytest.raises(TypeError):
        model._classify(5)

def test_classify_features_with_non_numeric():
    # Test with features containing non-numeric types (should raise error)
    model = AlexNet(num_classes=10)
    with pytest.raises(TypeError):
        model._classify([1, "a", 3])

def test_classify_large_negative_sum():
    # Test with features that sum to a large negative value
    model = AlexNet(num_classes=10)
    features = [-1000, -2000, -3000]
    expected = [sum(features) % 10] * len(features)
    codeflash_output = model._classify(features) # 1.50μs -> 801ns (87.6% faster)

# 3. Large Scale Test Cases

def test_classify_large_list():
    # Test with a large list of features
    model = AlexNet(num_classes=100)
    features = [random.randint(0, 100) for _ in range(1000)]
    expected = [sum(features) % 100] * 1000
    codeflash_output = model._classify(features) # 41.0μs -> 5.76μs (612% faster)

def test_classify_large_list_negative():
    # Test with a large list of negative features
    model = AlexNet(num_classes=50)
    features = [random.randint(-1000, -1) for _ in range(1000)]
    expected = [sum(features) % 50] * 1000
    codeflash_output = model._classify(features) # 42.4μs -> 6.36μs (566% faster)

def test_classify_large_list_mixed():
    # Test with a large list of mixed positive and negative features
    model = AlexNet(num_classes=77)
    features = [random.randint(-500, 500) for _ in range(1000)]
    expected = [sum(features) % 77] * 1000
    codeflash_output = model._classify(features) # 44.8μs -> 8.73μs (414% faster)

def test_classify_large_list_all_zeros():
    # Test with a large list of all zeros
    model = AlexNet(num_classes=13)
    features = [0] * 1000
    expected = [0] * 1000
    codeflash_output = model._classify(features) # 37.4μs -> 5.67μs (560% faster)

def test_classify_large_list_all_same_value():
    # Test with a large list of all the same value
    model = AlexNet(num_classes=333)
    features = [7] * 1000
    expected = [sum(features) % 333] * 1000
    codeflash_output = model._classify(features) # 40.6μs -> 5.52μs (635% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.